﻿using System;
using System.Collections.Generic;
using System.Linq;
using System.Text;

namespace EasyTrader.Option
{
    public class CompVal : IComparable<CompVal>
    {
#region Approach Info

        private double m_Delta = 0.0;
        public double Delta
        {
            get { return m_Delta; }
            set { m_Delta = value; }
        }
        private double m_DeltaTarget = 0.0;
        public double DeltaTarget
        {
            get { return m_DeltaTarget; }
            set { m_DeltaTarget = value; }
        }

        // 현재가에서 목표가를 빼준다.  
        private double m_DeltaY = 100.0;
        public double DeltaY
        {
            get { return m_DeltaY; }
            set { m_DeltaY = value; }
        }

        private int m_FirstUpInState = GlobalVar.NoneRange; // 오차 영역 아래에서 위로 처음으로 접근한 상태
        public int FirstUpInState
        {
            get { return m_FirstUpInState; }
            set { m_FirstUpInState = value; }
        }
        private int m_FirstDownInState = GlobalVar.NoneRange; // 오차 영역 위에서 아래로 처음으로 접근한 상태
        public int FirstDownInState
        {
            get { return m_FirstDownInState; }
            set { m_FirstDownInState = value; }
        }
        private int m_FirstUpInTime = 0;
        public int FirstUpInTime
        {
            get { return m_FirstUpInTime; }
            set { m_FirstUpInTime = value; }
        }
        private int m_FirstDownInTime = 0;
        public int FirstDownInTime
        {
            get { return m_FirstDownInTime; }
            set { m_FirstDownInTime = value; }
        }

        private int m_RecentRange = GlobalVar.NoneRange;
        public int RecentRange
        {
            get { return m_RecentRange; }
            set { m_RecentRange = value; }
        }
        private int m_RecentRangeTime = 0;
        public int RecentRangeTime
        {
            get { return m_RecentRangeTime; }
            set { m_RecentRangeTime = value; }
        }
#endregion

        private int m_Index = 0;
        public int Index
        {
            get { return m_Index; }
            set { m_Index = value; }
        }

        private double m_Y = 0.0;
        public double Y
        {
            get { return m_Y; }
            set { m_Y = value; }
        }
        private int m_ResistCount = 0;
        public int ResistCount
        {
            get { return m_ResistCount; }
            set { m_ResistCount = value; }
        }
        private int m_SupportCount = 0;
        public int SupportCount
        {
            get { return m_SupportCount; }
            set { m_SupportCount = value; }
        }
        private int m_FirstBreakDownState = GlobalVar.BreakNone;
        public int FirstBreakDownState
        {
            get { return m_FirstBreakDownState; }
            set { m_FirstBreakDownState = value; }
        }
        private int m_FirstBreakUpState = GlobalVar.BreakNone;
        public int FirstBreakUpState
        {
            get { return m_FirstBreakUpState; }
            set { m_FirstBreakUpState = value; }
        }


        private int m_FirstBreakUpTime = -1;
        public int FirstBreakUpTime
        {
            get { return m_FirstBreakUpTime; }
            set { m_FirstBreakUpTime = value; }
        }
        private int m_FirstBreakDownTime = -1;
        public int FirstBreakDownTime
        {
            get { return m_FirstBreakDownTime; }
            set { m_FirstBreakDownTime = value; }
        }


        private int m_Price = 0;
        public int Price
        {
            get { return m_Price; }
            set { m_Price = value; }
        }
        
        // 신호 시도 개수 - 하나의 가격에서 2번까지만 시도한다.
        private int m_TryCount = 0;
        public int TryCount
        {
            get { return m_TryCount; }
            set { m_TryCount = value; }
        }


        private double m_CurVal = 0.0;
        public double CurVal
        {
            get { return m_CurVal; }
            set { m_CurVal = value; }
        }


        private string m_BreakCode = "";
        public string BreakCode
        {
            get { return m_BreakCode; }
            set { m_BreakCode = value; }
        }

        private int m_FirstBreakTime = -1;
        public int FirstBreakTime
        {
            get { return m_FirstBreakTime; }
            set { m_FirstBreakTime = value; }
        }
        private int m_RecentBreakTime = -1;
        public int RecentBreakTime
        {
            get { return m_RecentBreakTime; }
            set { m_RecentBreakTime = value; }
        }
        /*
        private int m_BreakTime = 0;
        public int BreakTime
        {
            get { return m_BreakTime; }
            set { m_BreakTime = value; }
        }
        private int m_BreakIndex = 0;
        public int BreakIndex
        {
            get { return m_BreakIndex; }
            set { m_BreakIndex = value; }
        }*/
        private int m_SameType = -1;
        public int SameType
        {
            get { return m_SameType; }
            set { m_SameType = value; }
        }
        // 0 : 월저, 1 : 마디, 2 : 기준, 3 : 목표, 4 : 월고
        private int m_Type = -1;
        public int Type
        {
            get { return m_Type; }
            set { m_Type = value; }
        }
        private double m_Val = 0.0;
        public double Val
        {
            get { return m_Val; }
            set { m_Val = value; }
        }
        // 0 : 무포, 1 : 돌파, -1 : 붕괴
        private int m_RecentState = GlobalVar.BreakNone;
        public int RecentState
        {
            get { return m_RecentState; }
            set { m_RecentState = value; }
        }

        private int m_FirstState = GlobalVar.BreakNone;
        public int FirstState
        {
            get { return m_FirstState; }
            set { m_FirstState = value; }
        }
        // 부모 상태 감시자.
        private StateWatcher m_Watcher = null;
        public EasyTrader.Option.StateWatcher Watcher
        {
            get { return m_Watcher; }
            set { m_Watcher = value; }
        }

        public int CompareTo(EasyTrader.Option.CompVal b)
        {
            // Alphabetic sort name[A to Z]
            return this.Val.CompareTo(b.Val);
        }


        // 값의 상태를 업데이트 시켜준다. 
        public void UpdateBreakState(int a_State, int a_BreakIndex, int a_BreakTime)
        {
            // 상태가 달라졌을 때는 상태와 시간과 인덱스를 바꾸어 준다.
        }

        public void UpdateBreakState(int a_CurState, int a_CurTime)
        {
            // 상태가 달라졌을 때는 상태와 시간과 인덱스를 바꾸어 준다.
            if (RecentState != a_CurState)
            {
                m_RecentState = a_CurState;
                m_RecentBreakTime = a_CurTime;
            }
            // 첫 붕괴나 돌파 시간이 정해져 있지 않았을 때
            if ((a_CurState == GlobalVar.BreakDown || a_CurState == GlobalVar.BreakUp || a_CurState == GlobalVar.Resist || a_CurState == GlobalVar.Support) && FirstState == GlobalVar.BreakNone)
            {
                string sideCode = BreakCode.Substring(0, 1);
                if (sideCode == "2" && GlobalVar.FirstCallGot == false)
                {
                    m_FirstBreakTime = a_CurTime;
                    m_FirstState = a_CurState;
                    GlobalVar.FirstCallGot = true;
                    Console.WriteLine(">>>>>>callState" + this.RecentState.ToString());
                    Console.WriteLine(">>>>>>callTime" + this.RecentBreakTime.ToString());
                    Console.WriteLine(">>>>>>callVal" + this.Val.ToString("F2"));
                    Console.WriteLine(">>>>>>callCode" + this.BreakCode);
                    Console.WriteLine(">>>>>>callCurVal" + this.CurVal.ToString("F2"));
                    Console.WriteLine(">>>>>>callFirstState" + FirstState.ToString());
                }

                if (sideCode == "3" && GlobalVar.FirstPutGot == false)
                {
                    m_FirstBreakTime = a_CurTime;
                    m_FirstState = a_CurState;
                    GlobalVar.FirstPutGot = true;
                    Console.WriteLine(">>>>>>putState" + this.RecentState.ToString());
                    Console.WriteLine(">>>>>>putTime" + this.RecentBreakTime.ToString());
                    Console.WriteLine(">>>>>>putVal" + this.Val.ToString("F2"));
                    Console.WriteLine(">>>>>>putCode" + this.BreakCode);
                    Console.WriteLine(">>>>>>putCurVal" + this.CurVal.ToString("F2"));
                    Console.WriteLine(">>>>>>putFirstState" + FirstState.ToString());
                }
                
            }

            // 첫 붕괴가 정해지지 않았을 때
            if ((a_CurState == GlobalVar.BreakDown || a_CurState == GlobalVar.Resist) && FirstBreakDownState == GlobalVar.BreakNone)
            {
                m_FirstBreakDownState = GlobalVar.BreakDown;
                m_FirstBreakDownTime = a_CurTime;
            }
            // 첫 돌파가 정해지지 않았을 때
            if ((a_CurState == GlobalVar.BreakUp || a_CurState == GlobalVar.Support) && FirstBreakUpState == GlobalVar.BreakNone)
            {
                m_FirstBreakUpState = GlobalVar.BreakUp;
                m_FirstBreakUpTime = a_CurTime;
            }
        }

        public void InitBreakState()
        {
            /*
            // 상태가 달라졌을 때는 상태와 시간과 인덱스를 바꾸어 준다.
            m_FirstState = GlobalVar.BreakNone;
            m_RecentState = GlobalVar.BreakNone;
            m_FirstDownInState = GlobalVar.NoneRange;
            m_FirstUpInState = GlobalVar.NoneRange;
            m_FirstDownInTime = -1;
            m_FirstUpInTime = -1;
            m_TryCount = 0;
            m_FirstBreakDownTime = -1;
            m_FirstBreakUpTime = -1;
            m_FirstBreakDownState = GlobalVar.BreakNone;
            m_FirstBreakUpState = GlobalVar.BreakNone;
             */ 
        }
    }

    public class SortOnDeltaTargetAscend : IComparer<EasyTrader.Option.CompVal>
    {
        public int Compare(EasyTrader.Option.CompVal a, EasyTrader.Option.CompVal b)
        {
            if (a.DeltaTarget > b.DeltaTarget) return 1;
            else if (a.DeltaTarget < b.DeltaTarget) return -1;
            else return 0;
        }
    }

    


    // 시간은 오름 차순, 행사가 오름차순, 비교값 오름차순
    public class SortOnFTimeAPriceAValA : IComparer<EasyTrader.Option.CompVal>
    {
        public int Compare(EasyTrader.Option.CompVal a, EasyTrader.Option.CompVal b)
        {
            if (a.FirstBreakTime > b.FirstBreakTime) return 1;
            else if (a.FirstBreakTime < b.FirstBreakTime) return -1;
            else
            {
                // 시간이 같을 때 콜을 내가(가격이 작은 것부터 먼저 오게 한다.) 우선으로 한다.
                if (a.Price > b.Price)
                    return 1;
                else if (a.Price < b.Price)
                    return -1;
                else
                {
                    // 행사가가 같을 때 가격은 오름차순(작은 것부터 먼저오게 한다).
                    if (a.Val > b.Val)
                        return 1;
                    else if (a.Val < b.Val)
                        return -1;
                    else
                        return 0;
                }
            }
        }
    }

    // 시간은 오름 차순, 행사가 오름차순, 비교값 내림차순
    public class SortOnFTimeAPriceAValD : IComparer<EasyTrader.Option.CompVal>
    {
        public int Compare(EasyTrader.Option.CompVal a, EasyTrader.Option.CompVal b)
        {
            if (a.FirstBreakTime > b.FirstBreakTime) return 1;
            else if (a.FirstBreakTime < b.FirstBreakTime) return -1;
            else
            {
                // 시간이 같을 때 콜을 내가(가격이 작은 것부터 먼저 오게 한다.) 우선으로 한다.
                if (a.Price > b.Price)
                    return 1;
                else if (a.Price < b.Price)
                    return -1;
                else
                {
                    // 행사가가 같을 때 가격은 내림차순(큰 것부터 먼저오게 한다).
                    if (a.Val < b.Val)
                        return 1;
                    else if (a.Val > b.Val)
                        return -1;
                    else
                        return 0;
                }
            }
        }
    }


    // 시간은 오름 차순, 행사가 오름차순, 비교값 오름차순
    public class SortOnFBUTimeAPriceAValA : IComparer<EasyTrader.Option.CompVal>
    {
        public int Compare(EasyTrader.Option.CompVal a, EasyTrader.Option.CompVal b)
        {
            if (a.FirstBreakUpTime > b.FirstBreakUpTime) return 1;
            else if (a.FirstBreakUpTime < b.FirstBreakUpTime) return -1;
            else
            {
                // 시간이 같을 때 콜을 내가(가격이 작은 것부터 먼저 오게 한다.) 우선으로 한다.
                if (a.Price > b.Price)
                    return 1;
                else if (a.Price < b.Price)
                    return -1;
                else
                {
                    // 행사가가 같을 때 가격은 오름차순(작은 것부터 먼저오게 한다).
                    if (a.Val > b.Val)
                        return 1;
                    else if (a.Val < b.Val)
                        return -1;
                    else
                        return 0;
                }
            }
        }
    }

    // 시간은 오름 차순, 행사가 오름차순, 비교값 내림차순
    public class SortOnFBUTimeAPriceAValD : IComparer<EasyTrader.Option.CompVal>
    {
        public int Compare(EasyTrader.Option.CompVal a, EasyTrader.Option.CompVal b)
        {
            if (a.FirstBreakUpTime > b.FirstBreakUpTime) return 1;
            else if (a.FirstBreakUpTime < b.FirstBreakUpTime) return -1;
            else
            {
                // 시간이 같을 때 콜을 내가(가격이 작은 것부터 먼저 오게 한다.) 우선으로 한다.
                if (a.Price > b.Price)
                    return 1;
                else if (a.Price < b.Price)
                    return -1;
                else
                {
                    // 행사가가 같을 때 가격은 내림차순(큰 것부터 먼저오게 한다).
                    if (a.Val < b.Val)
                        return 1;
                    else if (a.Val > b.Val)
                        return -1;
                    else
                        return 0;
                }
            }
        }
    }

    public class SortOnFBUTimeAPriceDValA : IComparer<EasyTrader.Option.CompVal>
    {
        public int Compare(EasyTrader.Option.CompVal a, EasyTrader.Option.CompVal b)
        {
            if (a.FirstBreakUpTime > b.FirstBreakUpTime) return 1;
            else if (a.FirstBreakUpTime < b.FirstBreakUpTime) return -1;
            else
            {
                // 시간이 같을 때 콜을 내가(가격이 작은 것부터 먼저 오게 한다.) 우선으로 한다.
                if (a.Price < b.Price)
                    return 1;
                else if (a.Price > b.Price)
                    return -1;
                else
                {
                    // 행사가가 같을 때 가격은 오름차순(작은 것부터 먼저오게 한다).
                    if (a.Val > b.Val)
                        return 1;
                    else if (a.Val < b.Val)
                        return -1;
                    else
                        return 0;
                }
            }
        }
    }

    public class SortOnFBUTimeAPriceDValD : IComparer<EasyTrader.Option.CompVal>
    {
        public int Compare(EasyTrader.Option.CompVal a, EasyTrader.Option.CompVal b)
        {
            if (a.FirstBreakUpTime > b.FirstBreakUpTime) return 1;
            else if (a.FirstBreakUpTime < b.FirstBreakUpTime) return -1;
            else
            {
                // 시간이 같을 때 콜을 내가(가격이 작은 것부터 먼저 오게 한다.) 우선으로 한다.
                if (a.Price < b.Price)
                    return 1;
                else if (a.Price > b.Price)
                    return -1;
                else
                {
                    // 행사가가 같을 때 가격은 내림차순(큰 것부터 먼저오게 한다).
                    if (a.Val < b.Val)
                        return 1;
                    else if (a.Val > b.Val)
                        return -1;
                    else
                        return 0;
                }
            }
        }
    }


    public class SortOnFTimeAPriceDValA : IComparer<EasyTrader.Option.CompVal>
    {
        public int Compare(EasyTrader.Option.CompVal a, EasyTrader.Option.CompVal b)
        {
            if (a.FirstBreakTime > b.FirstBreakTime) return 1;
            else if (a.FirstBreakTime < b.FirstBreakTime) return -1;
            else
            {
                // 시간이 같을 때 콜을 내가(가격이 작은 것부터 먼저 오게 한다.) 우선으로 한다.
                if (a.Price < b.Price)
                    return 1;
                else if (a.Price > b.Price)
                    return -1;
                else
                {
                    // 행사가가 같을 때 가격은 오름차순(작은 것부터 먼저오게 한다).
                    if (a.Val > b.Val)
                        return 1;
                    else if (a.Val < b.Val)
                        return -1;
                    else
                        return 0;
                }
            }
        }
    }

    public class SortOnFTimeAPriceDValD : IComparer<EasyTrader.Option.CompVal>
    {
        public int Compare(EasyTrader.Option.CompVal a, EasyTrader.Option.CompVal b)
        {
            if (a.FirstBreakTime > b.FirstBreakTime) return 1;
            else if (a.FirstBreakTime < b.FirstBreakTime) return -1;
            else
            {
                // 시간이 같을 때 콜을 내가(가격이 작은 것부터 먼저 오게 한다.) 우선으로 한다.
                if (a.Price < b.Price)
                    return 1;
                else if (a.Price > b.Price)
                    return -1;
                else
                {
                    // 행사가가 같을 때 가격은 내림차순(큰 것부터 먼저오게 한다).
                    if (a.Val < b.Val)
                        return 1;
                    else if (a.Val > b.Val)
                        return -1;
                    else
                        return 0;
                }
            }
        }
    }


    // 시간은 오름 차순, 행사가 오름차순, 비교값 오름차순
    public class SortOnFBDTimeAPriceAValA : IComparer<EasyTrader.Option.CompVal>
    {
        public int Compare(EasyTrader.Option.CompVal a, EasyTrader.Option.CompVal b)
        {
            if (a.FirstBreakDownTime > b.FirstBreakDownTime) return 1;
            else if (a.FirstBreakDownTime < b.FirstBreakDownTime) return -1;
            else
            {
                // 시간이 같을 때 콜을 내가(가격이 작은 것부터 먼저 오게 한다.) 우선으로 한다.
                if (a.Price > b.Price)
                    return 1;
                else if (a.Price < b.Price)
                    return -1;
                else
                {
                    // 행사가가 같을 때 가격은 오름차순(작은 것부터 먼저오게 한다).
                    if (a.Val > b.Val)
                        return 1;
                    else if (a.Val < b.Val)
                        return -1;
                    else
                        return 0;
                }
            }
        }
    }

    // 시간은 오름 차순, 행사가 오름차순, 비교값 내림차순
    public class SortOnFBDTimeAPriceAValD : IComparer<EasyTrader.Option.CompVal>
    {
        public int Compare(EasyTrader.Option.CompVal a, EasyTrader.Option.CompVal b)
        {
            if (a.FirstBreakDownTime > b.FirstBreakDownTime) return 1;
            else if (a.FirstBreakDownTime < b.FirstBreakDownTime) return -1;
            else
            {
                // 시간이 같을 때 콜을 내가(가격이 작은 것부터 먼저 오게 한다.) 우선으로 한다.
                if (a.Price > b.Price)
                    return 1;
                else if (a.Price < b.Price)
                    return -1;
                else
                {
                    // 행사가가 같을 때 가격은 내림차순(큰 것부터 먼저오게 한다).
                    if (a.Val < b.Val)
                        return 1;
                    else if (a.Val > b.Val)
                        return -1;
                    else
                        return 0;
                }
            }
        }
    }

    public class SortOnFBDTimeAPriceDValA : IComparer<EasyTrader.Option.CompVal>
    {
        public int Compare(EasyTrader.Option.CompVal a, EasyTrader.Option.CompVal b)
        {
            if (a.FirstBreakDownTime > b.FirstBreakDownTime) return 1;
            else if (a.FirstBreakDownTime < b.FirstBreakDownTime) return -1;
            else
            {
                // 시간이 같을 때 콜을 내가(가격이 작은 것부터 먼저 오게 한다.) 우선으로 한다.
                if (a.Price < b.Price)
                    return 1;
                else if (a.Price > b.Price)
                    return -1;
                else
                {
                    // 행사가가 같을 때 가격은 오름차순(작은 것부터 먼저오게 한다).
                    if (a.Val > b.Val)
                        return 1;
                    else if (a.Val < b.Val)
                        return -1;
                    else
                        return 0;
                }
            }
        }
    }

    public class SortOnFBDTimeAPriceDValD : IComparer<EasyTrader.Option.CompVal>
    {
        public int Compare(EasyTrader.Option.CompVal a, EasyTrader.Option.CompVal b)
        {
            if (a.FirstBreakDownTime > b.FirstBreakDownTime) return 1;
            else if (a.FirstBreakDownTime < b.FirstBreakDownTime) return -1;
            else
            {
                // 시간이 같을 때 콜을 내가(가격이 작은 것부터 먼저 오게 한다.) 우선으로 한다.
                if (a.Price < b.Price)
                    return 1;
                else if (a.Price > b.Price)
                    return -1;
                else
                {
                    // 행사가가 같을 때 가격은 내림차순(큰 것부터 먼저오게 한다).
                    if (a.Val < b.Val)
                        return 1;
                    else if (a.Val > b.Val)
                        return -1;
                    else
                        return 0;
                }
            }
        }
    }


    // 시간은 오름 차순, 행사가 오름차순, 비교값 오름차순
    public class SortOnRTimeAPriceAValA : IComparer<EasyTrader.Option.CompVal>
    {
        public int Compare(EasyTrader.Option.CompVal a, EasyTrader.Option.CompVal b)
        {
            if (a.RecentBreakTime > b.RecentBreakTime) return 1;
            else if (a.RecentBreakTime < b.RecentBreakTime) return -1;
            else
            {
                // 시간이 같을 때 콜을 내가(가격이 작은 것부터 먼저 오게 한다.) 우선으로 한다.
                if (a.Price > b.Price)
                    return 1;
                else if (a.Price < b.Price)
                    return -1;
                else
                {
                    // 행사가가 같을 때 가격은 오름차순(작은 것부터 먼저오게 한다).
                    if (a.Val > b.Val)
                        return 1;
                    else if (a.Val < b.Val)
                        return -1;
                    else
                        return 0;
                }
            }
        }
    }

    // 시간은 오름 차순, 행사가 오름차순, 비교값 내림차순
    public class SortOnRTimeAPriceAValD : IComparer<EasyTrader.Option.CompVal>
    {
        public int Compare(EasyTrader.Option.CompVal a, EasyTrader.Option.CompVal b)
        {
            if (a.RecentBreakTime > b.RecentBreakTime) return 1;
            else if (a.RecentBreakTime < b.RecentBreakTime) return -1;
            else
            {
                // 시간이 같을 때 콜을 내가(가격이 작은 것부터 먼저 오게 한다.) 우선으로 한다.
                if (a.Price > b.Price)
                    return 1;
                else if (a.Price < b.Price)
                    return -1;
                else
                {
                    // 행사가가 같을 때 가격은 내림차순(큰 것부터 먼저오게 한다).
                    if (a.Val < b.Val)
                        return 1;
                    else if (a.Val > b.Val)
                        return -1;
                    else
                        return 0;
                }
            }
        }
    }


    public class SortOnRTimeAPriceDValA : IComparer<EasyTrader.Option.CompVal>
    {
        public int Compare(EasyTrader.Option.CompVal a, EasyTrader.Option.CompVal b)
        {
            if (a.RecentBreakTime > b.RecentBreakTime) return 1;
            else if (a.RecentBreakTime < b.RecentBreakTime) return -1;
            else
            {
                // 시간이 같을 때 콜을 내가(가격이 작은 것부터 먼저 오게 한다.) 우선으로 한다.
                if (a.Price < b.Price)
                    return 1;
                else if (a.Price > b.Price)
                    return -1;
                else
                {
                    // 행사가가 같을 때 가격은 오름차순(작은 것부터 먼저오게 한다).
                    if (a.Val > b.Val)
                        return 1;
                    else if (a.Val < b.Val)
                        return -1;
                    else
                        return 0;
                }
            }
        }
    }

    public class SortOnRTimeAPriceDValD : IComparer<EasyTrader.Option.CompVal>
    {
        public int Compare(EasyTrader.Option.CompVal a, EasyTrader.Option.CompVal b)
        {
            if (a.RecentBreakTime > b.RecentBreakTime) return 1;
            else if (a.RecentBreakTime < b.RecentBreakTime) return -1;
            else
            {
                // 시간이 같을 때 콜을 내가(가격이 작은 것부터 먼저 오게 한다.) 우선으로 한다.
                if (a.Price < b.Price)
                    return 1;
                else if (a.Price > b.Price)
                    return -1;
                else
                {
                    // 행사가가 같을 때 가격은 내림차순(큰 것부터 먼저오게 한다).
                    if (a.Val < b.Val)
                        return 1;
                    else if (a.Val > b.Val)
                        return -1;
                    else
                        return 0;
                }
            }
        }
    }

    public class SortOnDeltaTargetDescend : IComparer<EasyTrader.Option.CompVal>
    {
        public int Compare(EasyTrader.Option.CompVal a, EasyTrader.Option.CompVal b)
        {
            if (a.DeltaTarget < b.DeltaTarget) return 1;
            else if (a.DeltaTarget > b.DeltaTarget) return -1;
            else
            {
                return 0;
            }
        }
    }
}
